<HTML>
<HEAD>

<TITLE>Network Messages</TITLE>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"></HEAD>
<link href="RaknetManual.css" rel="stylesheet" type="text/css">
<meta name="title" content="RakNet - Advanced multiplayer game networking API">
</HEAD>
<BODY BGCOLOR="#ffffff" LINK="#003399" vlink="#003399" alink="#003399" LEFTMARGIN="0" TOPMARGIN="0" MARGINWIDTH="0" MARGINHEIGHT="0"">
<span style="background-color: rgb(255, 255, 255);"><img src="RakNet_Icon_Final-copy.jpg" alt="Oculus VR, Inc." width="150" height="150"></span><BR>
<BR>

<table width="100%" border="0"><tr><td bgcolor="#2c5d92" class="RakNetWhiteHeader">
<img src="spacer.gif" width="8" height="1">Network Messages</td>
</tr></table>
<TABLE BORDER="0" CELLPADDING="10" CELLSPACING="0" WIDTH="100%"><TR><TD>
  <p>Messages from the network engine
    <BR>
    <BR>
    
      Certain packets that you get will not be from your code, using your defined types, but are instead from the network engine. However, you have to know what they are to handle them properly.  The first byte of each packet that originated from the API will map to one of the following enumerations. Possible recipient systems are in brackets. To convert these enumerations to a string, use PacketLogger::BaseIDTOString() </p>
 
  <p class="RakNetCode">//<br>
    // RESERVED TYPES - DO NOT CHANGE THESE<br>
    // All types from RakPeer<br>
    //<br>
    /// These types are never returned to the user.<br>
    /// Ping from a connected system.  Update timestamps (internal use only)<br>
    ID_CONNECTED_PING, <br>
    /// Ping from an unconnected system.  Reply but do not update timestamps. (internal use only)<br>
    ID_UNCONNECTED_PING,<br>
    /// Ping from an unconnected system.  Only reply if we have open connections. Do not update timestamps. (internal use only)<br>
    ID_UNCONNECTED_PING_OPEN_CONNECTIONS,<br>
    /// Pong from a connected system.  Update timestamps (internal use only)<br>
    ID_CONNECTED_PONG,<br>
    /// A reliable packet to detect lost connections (internal use only)<br>
    ID_DETECT_LOST_CONNECTIONS,<br>
    /// C2S: Initial query: Header(1), OfflineMesageID(16), Protocol number(1), Pad(toMTU), sent with no fragment set.<br>
    /// If protocol fails on server, returns ID_INCOMPATIBLE_PROTOCOL_VERSION to client<br>
    ID_OPEN_CONNECTION_REQUEST_1,<br>
    /// S2C: Header(1), OfflineMesageID(16), server GUID(8), HasSecurity(1), Cookie(4, if HasSecurity)<br>
    /// , public key (if do security is true), MTU(2). If public key fails on client, returns ID_PUBLIC_KEY_MISMATCH<br>
    ID_OPEN_CONNECTION_REPLY_1,<br>
    /// C2S: Header(1), OfflineMesageID(16), Cookie(4, if HasSecurity is true on the server), clientSupportsSecurity(1 bit),<br>
    /// handshakeChallenge (if has security on both server and client), remoteBindingAddress(6), MTU(2), client GUID(8)<br>
    /// Connection slot allocated if cookie is valid, server is not full, GUID and IP not already in use.<br>
    ID_OPEN_CONNECTION_REQUEST_2,<br>
    /// S2C: Header(1), OfflineMesageID(16), server GUID(8), mtu(2), doSecurity(1 bit), handshakeAnswer (if do security is true)<br>
    ID_OPEN_CONNECTION_REPLY_2,<br>
    /// C2S: Header(1), GUID(8), Timestamp, HasSecurity(1), Proof(32)<br>
    ID_CONNECTION_REQUEST,<br>
    /// RakPeer - Remote system requires secure connections, pass a public key to RakPeerInterface::Connect()<br>
    ID_REMOTE_SYSTEM_REQUIRES_PUBLIC_KEY,<br>
    /// RakPeer - We passed a public key to RakPeerInterface::Connect(), but the other system did not have security turned on<br>
    ID_OUR_SYSTEM_REQUIRES_SECURITY,<br>
    /// RakPeer - Wrong public key passed to RakPeerInterface::Connect()<br>
    ID_PUBLIC_KEY_MISMATCH,<br>
    /// RakPeer - Same as ID_ADVERTISE_SYSTEM, but intended for internal use rather than being passed to the user.<br>
    /// Second byte indicates type. Used currently for NAT punchthrough for receiver port advertisement. See ID_NAT_ADVERTISE_RECIPIENT_PORT<br>
    ID_OUT_OF_BAND_INTERNAL,<br>
    /// If RakPeerInterface::Send() is called where PacketReliability contains _WITH_ACK_RECEIPT, then on a later call to<br>
    /// RakPeerInterface::Receive() you will get ID_SND_RECEIPT_ACKED or ID_SND_RECEIPT_LOSS. The message will be 5 bytes long,<br>
    /// and bytes 1-4 inclusive will contain a number in native order containing a number that identifies this message.<br>
    /// This number will be returned by RakPeerInterface::Send() or RakPeerInterface::SendList(). ID_SND_RECEIPT_ACKED means that<br>
    /// the message arrived<br>
    ID_SND_RECEIPT_ACKED,<br>
    /// If RakPeerInterface::Send() is called where PacketReliability contains _WITH_ACK_RECEIPT, then on a later call to<br>
    /// RakPeerInterface::Receive() you will get ID_SND_RECEIPT_ACKED or ID_SND_RECEIPT_LOSS. The message will be 5 bytes long,<br>
    /// and bytes 1-4 inclusive will contain a number in native order containing a number that identifies this message. This number<br>
    /// will be returned by RakPeerInterface::Send() or RakPeerInterface::SendList(). ID_SND_RECEIPT_LOSS means that an ack for the<br>
    /// message did not arrive (it may or may not have been delivered, probably not). On disconnect or shutdown, you will not get<br>
    /// ID_SND_RECEIPT_LOSS for unsent messages, you should consider those messages as all lost.<br>
    ID_SND_RECEIPT_LOSS,<br>
  </p>
  <p class="RakNetCode"> //<br>
    // USER TYPES - DO NOT CHANGE THESE<br>
    //</p>
  <p class="RakNetCode"> /// RakPeer - In a client/server environment, our connection request to the server has been accepted.<br>
    ID_CONNECTION_REQUEST_ACCEPTED,<br>
    /// RakPeer - Sent to the player when a connection request cannot be completed due to inability to connect. <br>
    ID_CONNECTION_ATTEMPT_FAILED,<br>
    /// RakPeer - Sent a connect request to a system we are currently connected to.<br>
    ID_ALREADY_CONNECTED,<br>
    /// RakPeer - A remote system has successfully connected.<br>
    ID_NEW_INCOMING_CONNECTION,<br>
    /// RakPeer - The system we attempted to connect to is not accepting new connections.<br>
    ID_NO_FREE_INCOMING_CONNECTIONS,<br>
    /// RakPeer - The system specified in Packet::systemAddress has disconnected from us.  For the client, this would mean the<br>
    /// server has shutdown. <br>
    ID_DISCONNECTION_NOTIFICATION,<br>
    /// RakPeer - Reliable packets cannot be delivered to the system specified in Packet::systemAddress.  The connection to that<br>
    /// system has been closed. <br>
    ID_CONNECTION_LOST,<br>
    /// RakPeer - We are banned from the system we attempted to connect to.<br>
    ID_CONNECTION_BANNED,<br>
    /// RakPeer - The remote system is using a password and has refused our connection because we did not set the correct password.<br>
    ID_INVALID_PASSWORD,<br>
    // RAKNET_PROTOCOL_VERSION in RakNetVersion.h does not match on the remote system what we have on our system<br>
    // This means the two systems cannot communicate.<br>
    // The 2nd byte of the message contains the value of RAKNET_PROTOCOL_VERSION for the remote system<br>
    ID_INCOMPATIBLE_PROTOCOL_VERSION,<br>
    // Means that this IP address connected recently, and can't connect again as a security measure. See<br>
    /// RakPeer::SetLimitIPConnectionFrequency()<br>
    ID_IP_RECENTLY_CONNECTED,<br>
    /// RakPeer - The sizeof(RakNetTime) bytes following this byte represent a value which is automatically modified by the difference<br>
    /// in system times between the sender and the recipient. Requires that you call SetOccasionalPing.<br>
    ID_TIMESTAMP,<br>
    /// RakPeer - Pong from an unconnected system.  First byte is ID_UNCONNECTED_PONG, second sizeof(RakNet::TimeMS) bytes is the ping,<br>
    /// following bytes is system specific enumeration data.<br>
    /// Read using bitstreams<br>
    ID_UNCONNECTED_PONG,<br>
    /// RakPeer - Inform a remote system of our IP/Port. On the recipient, all data past ID_ADVERTISE_SYSTEM is whatever was passed to<br>
    /// the data parameter<br>
    ID_ADVERTISE_SYSTEM,<br>
    // RakPeer - Downloading a large message. Format is ID_DOWNLOAD_PROGRESS (MessageID), partCount (unsigned int),<br>
    ///  partTotal (unsigned int),<br>
    /// partLength (unsigned int), first part data (length &lt;= MAX_MTU_SIZE). See the three parameters partCount, partTotal<br>
    ///  and partLength in OnFileProgress in FileListTransferCBInterface.h<br>
    ID_DOWNLOAD_PROGRESS,<br>
  <br>
    /// ConnectionGraph2 plugin - In a client/server environment, a client other than ourselves has disconnected gracefully.<br>
    ///   Packet::systemAddress is modified to reflect the systemAddress of this client.<br>
    ID_REMOTE_DISCONNECTION_NOTIFICATION,<br>
    /// ConnectionGraph2 plugin - In a client/server environment, a client other than ourselves has been forcefully dropped.<br>
    ///  Packet::systemAddress is modified to reflect the systemAddress of this client.<br>
    ID_REMOTE_CONNECTION_LOST,<br>
    /// ConnectionGraph2 plugin: Bytes 1-4 = count. for (count items) contains {SystemAddress, RakNetGUID}<br>
    ID_REMOTE_NEW_INCOMING_CONNECTION,</p>
  <p class="RakNetCode"> /// FileListTransfer plugin - Setup data<br>
    ID_FILE_LIST_TRANSFER_HEADER,<br>
    /// FileListTransfer plugin - A file<br>
    ID_FILE_LIST_TRANSFER_FILE,<br>
    // Ack for reference push, to send more of the file<br>
    ID_FILE_LIST_REFERENCE_PUSH_ACK,</p>
  <p class="RakNetCode"> /// DirectoryDeltaTransfer plugin - Request from a remote system for a download of a directory<br>
    ID_DDT_DOWNLOAD_REQUEST,<br>
  <br>
    /// RakNetTransport plugin - Transport provider message, used for remote console<br>
    ID_TRANSPORT_STRING,</p>
  <p class="RakNetCode"> /// ReplicaManager plugin - Create an object<br>
    ID_REPLICA_MANAGER_CONSTRUCTION,<br>
    /// ReplicaManager plugin - Changed scope of an object<br>
    ID_REPLICA_MANAGER_SCOPE_CHANGE,<br>
    /// ReplicaManager plugin - Serialized data of an object<br>
    ID_REPLICA_MANAGER_SERIALIZE,<br>
    /// ReplicaManager plugin - New connection, about to send all world objects<br>
    ID_REPLICA_MANAGER_DOWNLOAD_STARTED,<br>
    /// ReplicaManager plugin - Finished downloading all serialized objects<br>
    ID_REPLICA_MANAGER_DOWNLOAD_COMPLETE,<br>
    /// Serialize construction for an object that already exists on the remote system<br>
    ID_REPLICA_MANAGER_3_SERIALIZE_CONSTRUCTION_EXISTING,<br>
    ID_REPLICA_MANAGER_3_LOCAL_CONSTRUCTION_REJECTED,<br>
    ID_REPLICA_MANAGER_3_LOCAL_CONSTRUCTION_ACCEPTED,</p>
  <p class="RakNetCode"> /// RakVoice plugin - Open a communication channel<br>
    ID_RAKVOICE_OPEN_CHANNEL_REQUEST,<br>
    /// RakVoice plugin - Communication channel accepted<br>
    ID_RAKVOICE_OPEN_CHANNEL_REPLY,<br>
    /// RakVoice plugin - Close a communication channel<br>
    ID_RAKVOICE_CLOSE_CHANNEL,<br>
    /// RakVoice plugin - Voice data<br>
    ID_RAKVOICE_DATA,</p>
  <p class="RakNetCode"> /// Autopatcher plugin - Get a list of files that have changed since a certain date<br>
    ID_AUTOPATCHER_GET_CHANGELIST_SINCE_DATE,<br>
    /// Autopatcher plugin - A list of files to create<br>
    ID_AUTOPATCHER_CREATION_LIST,<br>
    /// Autopatcher plugin - A list of files to delete<br>
    ID_AUTOPATCHER_DELETION_LIST,<br>
    /// Autopatcher plugin - A list of files to get patches for<br>
    ID_AUTOPATCHER_GET_PATCH,<br>
    /// Autopatcher plugin - A list of patches for a list of files<br>
    ID_AUTOPATCHER_PATCH_LIST,<br>
    /// Autopatcher plugin - Returned to the user: An error from the database repository for the autopatcher.<br>
    ID_AUTOPATCHER_REPOSITORY_FATAL_ERROR,<br>
    /// Autopatcher plugin - Finished getting all files from the autopatcher<br>
    ID_AUTOPATCHER_FINISHED_INTERNAL,<br>
    ID_AUTOPATCHER_FINISHED,<br>
    /// Autopatcher plugin - Returned to the user: You must restart the application to finish patching.<br>
    ID_AUTOPATCHER_RESTART_APPLICATION,</p>
  <p class="RakNetCode"> /// NATPunchthrough plugin: internal<br>
    ID_NAT_PUNCHTHROUGH_REQUEST,<br>
    /// NATPunchthrough plugin: internal<br>
    ID_NAT_CONNECT_AT_TIME,<br>
    /// NATPunchthrough plugin: internal<br>
    ID_NAT_GET_MOST_RECENT_PORT,<br>
    /// NATPunchthrough plugin: internal<br>
    ID_NAT_CLIENT_READY,</p>
  <p class="RakNetCode"> /// NATPunchthrough plugin: Destination system is not connected to the server. Bytes starting at offset 1 contains the<br>
    ///  RakNetGUID destination field of NatPunchthroughClient::OpenNAT().<br>
    ID_NAT_TARGET_NOT_CONNECTED,<br>
    /// NATPunchthrough plugin: Destination system is not responding to ID_NAT_GET_MOST_RECENT_PORT. Possibly the plugin is not installed.<br>
    ///  Bytes starting at offset 1 contains the RakNetGUID  destination field of NatPunchthroughClient::OpenNAT().<br>
    ID_NAT_TARGET_UNRESPONSIVE,<br>
    /// NATPunchthrough plugin: The server lost the connection to the destination system while setting up punchthrough.<br>
    ///  Possibly the plugin is not installed. Bytes starting at offset 1 contains the RakNetGUID  destination<br>
    ///  field of NatPunchthroughClient::OpenNAT().<br>
    ID_NAT_CONNECTION_TO_TARGET_LOST,<br>
    /// NATPunchthrough plugin: This punchthrough is already in progress. Possibly the plugin is not installed.<br>
    ///  Bytes starting at offset 1 contains the RakNetGUID destination field of NatPunchthroughClient::OpenNAT().<br>
    ID_NAT_ALREADY_IN_PROGRESS,<br>
    /// NATPunchthrough plugin: This message is generated on the local system, and does not come from the network.<br>
    ///  packet::guid contains the destination field of NatPunchthroughClient::OpenNAT(). Byte 1 contains 1 if you are the sender, 0 if not<br>
    ID_NAT_PUNCHTHROUGH_FAILED,<br>
    /// NATPunchthrough plugin: Punchthrough suceeded. See packet::systemAddress and packet::guid. Byte 1 contains 1 if you are the sender,<br>
    ///  0 if not. You can now use RakPeer::Connect() or other calls to communicate with this system.<br>
    ID_NAT_PUNCHTHROUGH_SUCCEEDED,</p>
  <p class="RakNetCode"> /// ReadyEvent plugin - Set the ready state for a particular system<br>
    /// First 4 bytes after the message contains the id<br>
    ID_READY_EVENT_SET,<br>
    /// ReadyEvent plugin - Unset the ready state for a particular system<br>
    /// First 4 bytes after the message contains the id<br>
    ID_READY_EVENT_UNSET,<br>
    /// All systems are in state ID_READY_EVENT_SET<br>
    /// First 4 bytes after the message contains the id<br>
    ID_READY_EVENT_ALL_SET,<br>
    /// \internal, do not process in your game<br>
    /// ReadyEvent plugin - Request of ready event state - used for pulling data when newly connecting<br>
    ID_READY_EVENT_QUERY,</p>
  <p class="RakNetCode"> /// Lobby packets. Second byte indicates type.<br>
    ID_LOBBY_GENERAL,</p>
  <p class="RakNetCode"> // RPC3, RPC4Plugin error<br>
    ID_RPC_REMOTE_ERROR,<br>
    /// Plugin based replacement for RPC system<br>
    ID_RPC_PLUGIN,</p>
  <p class="RakNetCode"> /// FileListTransfer transferring large files in chunks that are read only when needed, to save memory<br>
    ID_FILE_LIST_REFERENCE_PUSH,<br>
    /// Force the ready event to all set<br>
    ID_READY_EVENT_FORCE_ALL_SET,</p>
  <p class="RakNetCode"> /// Rooms function<br>
    ID_ROOMS_EXECUTE_FUNC,<br>
    ID_ROOMS_LOGON_STATUS,<br>
    ID_ROOMS_HANDLE_CHANGE,</p>
  <p class="RakNetCode"> /// Lobby2 message<br>
    ID_LOBBY2_SEND_MESSAGE,<br>
    ID_LOBBY2_SERVER_ERROR,</p>
  <p class="RakNetCode"> /// Informs user of a new host GUID. Packet::Guid contains this new host RakNetGuid. The old host can be read out using BitStream-&gt;Read(RakNetGuid) starting on byte 1<br>
    ID_FCM2_NEW_HOST,<br>
    /// \internal For FullyConnectedMesh2 plugin<br>
    ID_FCM2_REQUEST_FCMGUID,<br>
    /// \internal For FullyConnectedMesh2 plugin<br>
    ID_FCM2_RESPOND_CONNECTION_COUNT,<br>
    /// \internal For FullyConnectedMesh2 plugin<br>
    ID_FCM2_INFORM_FCMGUID,</p>
  <p class="RakNetCode"> /// UDP proxy messages. Second byte indicates type.<br>
    ID_UDP_PROXY_GENERAL,</p>
  <p class="RakNetCode"> /// SQLite3Plugin - execute<br>
    ID_SQLite3_EXEC,<br>
    /// SQLite3Plugin - Remote database is unknown<br>
    ID_SQLite3_UNKNOWN_DB,<br>
    /// Events happening with SQLiteClientLoggerPlugin<br>
    ID_SQLLITE_LOGGER,</p>
  <p class="RakNetCode"> /// Sent to NatTypeDetectionServer<br>
    ID_NAT_TYPE_DETECTION_REQUEST,<br>
    /// Sent to NatTypeDetectionClient. Byte 1 contains the type of NAT detected.<br>
    ID_NAT_TYPE_DETECTION_RESULT,</p>
  <p class="RakNetCode"> /// Used by the router2 plugin<br>
    ID_ROUTER_2_INTERNAL,<br>
    /// No path is available or can be established to the remote system<br>
    /// Packet::guid contains the endpoint guid that we were trying to reach<br>
    ID_ROUTER_2_FORWARDING_NO_PATH,<br>
    /// \brief You can now call connect, ping, or other operations to the destination system.<br>
    ///<br>
    /// Connect as follows:<br>
    ///<br>
    /// RakNet::BitStream bs(packet-&gt;data, packet-&gt;length, false);<br>
    /// bs.IgnoreBytes(sizeof(MessageID));<br>
    /// RakNetGUID endpointGuid;<br>
    /// bs.Read(endpointGuid);<br>
    /// unsigned short sourceToDestPort;<br>
    /// bs.Read(sourceToDestPort);<br>
    /// char ipAddressString[32];<br>
    /// packet-&gt;systemAddress.ToString(false, ipAddressString);<br>
    /// rakPeerInterface-&gt;Connect(ipAddressString, sourceToDestPort, 0,0);<br>
    ID_ROUTER_2_FORWARDING_ESTABLISHED,<br>
    /// The IP address for a forwarded connection has changed<br>
    /// Read endpointGuid and port as per ID_ROUTER_2_FORWARDING_ESTABLISHED<br>
    ID_ROUTER_2_REROUTED,</p>
  <p class="RakNetCode"> /// \internal Used by the team balancer plugin<br>
    ID_TEAM_BALANCER_INTERNAL,<br>
    /// Cannot switch to the desired team because it is full. However, if someone on that team leaves, you will<br>
    ///  get ID_TEAM_BALANCER_SET_TEAM later. Byte 1 contains the team you requested to join.<br>
    ID_TEAM_BALANCER_REQUESTED_TEAM_CHANGE_PENDING,<br>
    /// Cannot switch to the desired team because all teams are locked. However, if someone on that team leaves,<br>
    ///  you will get ID_TEAM_BALANCER_SET_TEAM later. Byte 1 contains the team you requested to join.<br>
    ID_TEAM_BALANCER_TEAMS_LOCKED,<br>
    /// Team balancer plugin informing you of your team. Byte 1 contains the team you requested to join.<br>
    ID_TEAM_BALANCER_TEAM_ASSIGNED,</p>
  <p class="RakNetCode"> /// Gamebryo Lightspeed integration<br>
    ID_LIGHTSPEED_INTEGRATION,</p>
  <p class="RakNetCode"> /// XBOX integration<br>
    ID_XBOX_LOBBY,</p>
  <p class="RakNetCode"> /// The password we used to challenge the other system passed, meaning the other system has called TwoWayAuthentication::AddPassword() with the same password we passed to TwoWayAuthentication::Challenge()<br>
    /// You can read the identifier used to challenge as follows:<br>
    /// RakNet::BitStream bs(packet-&gt;data, packet-&gt;length, false); bs.IgnoreBytes(sizeof(RakNet::MessageID)); RakNet::RakString password; bs.Read(password);<br>
    ID_TWO_WAY_AUTHENTICATION_INCOMING_CHALLENGE_SUCCESS,<br>
    ID_TWO_WAY_AUTHENTICATION_OUTGOING_CHALLENGE_SUCCESS,<br>
    /// A remote system sent us a challenge using TwoWayAuthentication::Challenge(), and the challenge failed.<br>
    /// If the other system must pass the challenge to stay connected, you should call RakPeer::CloseConnection() to terminate the connection to the other system. <br>
    ID_TWO_WAY_AUTHENTICATION_INCOMING_CHALLENGE_FAILURE,<br>
    /// The other system did not add the password we used to TwoWayAuthentication::AddPassword()<br>
    /// You can read the identifier used to challenge as follows:<br>
    /// RakNet::BitStream bs(packet-&gt;data, packet-&gt;length, false); bs.IgnoreBytes(sizeof(MessageID)); RakNet::RakString password; bs.Read(password);<br>
    ID_TWO_WAY_AUTHENTICATION_OUTGOING_CHALLENGE_FAILURE,<br>
    /// The other system did not respond within a timeout threshhold. Either the other system is not running the plugin or the other system was blocking on some operation for a long time.<br>
    /// You can read the identifier used to challenge as follows:<br>
    /// RakNet::BitStream bs(packet-&gt;data, packet-&gt;length, false); bs.IgnoreBytes(sizeof(MessageID)); RakNet::RakString password; bs.Read(password);<br>
    ID_TWO_WAY_AUTHENTICATION_OUTGOING_CHALLENGE_TIMEOUT,<br>
    /// \internal<br>
    ID_TWO_WAY_AUTHENTICATION_NEGOTIATION,</p>
  <p class="RakNetCode"> /// CloudClient / CloudServer<br>
    ID_CLOUD_POST_REQUEST,<br>
    ID_CLOUD_RELEASE_REQUEST,<br>
    ID_CLOUD_GET_REQUEST,<br>
    ID_CLOUD_GET_RESPONSE,<br>
    ID_CLOUD_UNSUBSCRIBE_REQUEST,<br>
    ID_CLOUD_SERVER_TO_SERVER_COMMAND,<br>
    ID_CLOUD_SUBSCRIPTION_NOTIFICATION,</p>
  <p class="RakNetCode"> // So I can add more without changing user enumerations<br>
    ID_RESERVED_1,<br>
    ID_RESERVED_2,<br>
    ID_RESERVED_3,<br>
    ID_RESERVED_4,<br>
    ID_RESERVED_5,<br>
    ID_RESERVED_6,<br>
    ID_RESERVED_7,<br>
    ID_RESERVED_8,<br>
    ID_RESERVED_9,</p>
  <p class="RakNetCode"> // For the user to use.  Start your first enumeration at this value.<br>
    ID_USER_PACKET_ENUM,</p>
  <pre>&nbsp;</pre>
 
 </TD></TR></TABLE>
<table width="100%" border="0"><tr><td bgcolor="#2c5d92" class="RakNetWhiteHeader">
<img src="spacer.gif" width="8" height="1">See Also</td>
</tr></table>
<TABLE BORDER="0" CELLPADDING="10" CELLSPACING="0" WIDTH="100%"><TR><TD>

<A HREF="index.html">Index</A><BR>

</TD></TR></TABLE>
</BODY>
</HTML>
